// app/controller/organization_controller.js
'use strict';

const { Controller } = require('egg');

class OrganizationController extends Controller {
  // 获取组织列表
  async index() {
    const { ctx } = this;
    const { page = 1, limit = 20, name, status } = ctx.query;

    try {
      const result = await ctx.service.organizationService.getOrganizations({
        page: parseInt(page),
        limit: parseInt(limit),
        name,
        status
      });

      ctx.success(result);
    } catch (error) {
      ctx.logger.error('获取组织列表失败:', error);
      ctx.error(`获取组织列表失败: ${error.message}`);
    }
  }

  // 获取组织详情
  async show() {
    const { ctx } = this;
    const { id } = ctx.params;

    try {
      const organization = await ctx.service.organizationService.getOrganization(id);
      if (!organization) {
        ctx.error('组织不存在', 404);
        return;
      }

      ctx.success(organization);
    } catch (error) {
      ctx.logger.error('获取组织详情失败:', error);
      ctx.error(`获取组织详情失败: ${error.message}`);
    }
  }

  // 创建组织
  async create() {
    const { ctx } = this;
    const organizationData = ctx.request.body;

    try {
      const organization = await ctx.service.organizationService.createOrganization(organizationData);
      ctx.success(organization, '组织创建成功');
    } catch (error) {
      ctx.logger.error('创建组织失败:', error);
      ctx.error(`创建组织失败: ${error.message}`);
    }
  }

  // 更新组织
  async update() {
    const { ctx } = this;
    const { id } = ctx.params;
    const organizationData = ctx.request.body;

    try {
      const organization = await ctx.service.organizationService.updateOrganization(id, organizationData);
      ctx.success(organization, '组织更新成功');
    } catch (error) {
      ctx.logger.error('更新组织失败:', error);
      ctx.error(`更新组织失败: ${error.message}`);
    }
  }

  // 删除组织
  async destroy() {
    const { ctx } = this;
    const { id } = ctx.params;

    try {
      await ctx.service.organizationService.deleteOrganization(id);
      ctx.success(null, '组织删除成功');
    } catch (error) {
      ctx.logger.error('删除组织失败:', error);
      ctx.error(`删除组织失败: ${error.message}`);
    }
  }

  // 获取用户所属的组织
  async getUserOrganizations() {
    const { ctx } = this;
    const { userId } = ctx.params;

    try {
      // 如果userId是'current'或不是有效数字，则从token中获取当前用户ID
      let targetUserId = userId;
      if (userId === 'current' || isNaN(parseInt(userId))) {
        // 从token中获取当前用户ID，通常在Egg.js中用户信息存储在ctx.state.user中
        targetUserId = ctx.state.user?.id;
        
        // 如果仍然没有用户ID，返回错误
        if (!targetUserId) {
          ctx.error('无法获取当前用户信息，请确保已登录', 400);
          return;
        }
      } else {
        targetUserId = parseInt(userId);
      }

      // 如果仍然没有有效的用户ID，则返回错误
      if (!targetUserId) {
        ctx.error('用户ID无效', 400);
        return;
      }

      const organizations = await ctx.service.organizationService.getUserOrganizations(targetUserId);
      ctx.success(organizations);
    } catch (error) {
      ctx.logger.error('获取用户组织失败:', error);
      ctx.error(`获取用户组织失败: ${error.message}`);
    }
  }

  // 添加用户到组织
  async addUserToOrganization() {
    const { ctx } = this;
    const { userId, organizationId, role } = ctx.request.body;

    try {
      // 验证用户是否有权限执行此操作（只有管理员或组织所有者可以添加用户）
      if (!ctx.state.user || (ctx.state.user.role !== 'admin' && ctx.state.user.id !== userId)) {
        ctx.error('您没有权限执行此操作', 403);
        return;
      }

      const result = await ctx.service.organizationService.addUserToOrganization(userId, organizationId, role);
      ctx.success(result, '用户添加到组织成功');
    } catch (error) {
      ctx.logger.error('添加用户到组织失败:', error);
      ctx.error(`添加用户到组织失败: ${error.message}`);
    }
  }

  // 从组织移除用户
  async removeUserFromOrganization() {
    const { ctx } = this;
    const { userId, organizationId } = ctx.request.body;

    try {
      // 验证用户是否有权限执行此操作（只有管理员或组织所有者可以移除用户）
      if (!ctx.state.user || (ctx.state.user.role !== 'admin' && ctx.state.user.id !== userId)) {
        ctx.error('您没有权限执行此操作', 403);
        return;
      }

      await ctx.service.organizationService.removeUserFromOrganization(userId, organizationId);
      ctx.success(null, '用户从组织移除成功');
    } catch (error) {
      ctx.logger.error('从组织移除用户失败:', error);
      ctx.error(`从组织移除用户失败: ${error.message}`);
    }
  }

  // 获取用户在组织中的角色
  async getUserRoleInOrganization() {
    const { ctx } = this;
    const { userId, organizationId } = ctx.params;

    try {
      const userOrganization = await ctx.model.UserOrganizationModel.findOne({
        where: {
          userId: parseInt(userId),
          organizationId: parseInt(organizationId)
        }
      });

      if (!userOrganization) {
        ctx.error('用户不在该组织中', 404);
        return;
      }

      ctx.success({
        role: userOrganization.role,
        status: userOrganization.status
      });
    } catch (error) {
      ctx.logger.error('获取用户角色失败:', error);
      ctx.error(`获取用户角色失败: ${error.message}`);
    }
  }
}

module.exports = OrganizationController;